home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / misc / emu / msh-156.lha / util / setmain.c < prev    next >
C/C++ Source or Header  |  1996-12-22  |  17KB  |  864 lines
  1. /*-
  2.  * $Id: setmain.c,v 1.56 1996/12/22 21:12:51 Rhialto Rel $
  3.  * $Log: setmain.c,v $
  4.  * Revision 1.56  1996/12/22  21:12:51  Rhialto
  5.  * Cosmetics.
  6.  *
  7.  * Revision 1.56  1996/12/22  00:22:33  Rhialto
  8.  * Cosmetics.
  9.  *
  10.  * Revision 1.55  1993/12/30  23:28:00    Rhialto
  11.  * Freeze for MAXON5.
  12.  * New GadToolBox (2.0c), and use font-sensitive option.
  13.  *
  14.  * Revision 1.54  1993/06/24  05:35:45    Rhialto
  15.  * DICE 2.07.54R.
  16.  *
  17.  * Revision 1.53  92/10/25  02:47:12  Rhialto
  18.  * Initial revision.
  19.  *
  20.  *  SET MAIN.C
  21.  *
  22.  *  The main file of the MSH settings commodity.
  23.  *
  24.  *  This code is (C) Copyright 1992 by Olaf Seibert. All rights reserved.
  25.  *  May not be used or copied without a licence.
  26. -*/
  27.  
  28. #define INTUI_V36_NAMES_ONLY
  29.  
  30. #include "han.h"
  31. #include "hanconv.h"
  32.  
  33. #ifndef LIBRARIES_GADTOOLS_H
  34. #include <libraries/gadtools.h>
  35. #endif
  36. #ifndef LIBRARIES_ASL_H
  37. #include <libraries/asl.h>
  38. #endif
  39. #ifndef INTUITION_GADGETCLASS_H
  40. #include <intuition/gadgetclass.h>
  41. #endif
  42. #ifndef DOS_DOS_H
  43. #include <dos/dos.h>
  44. #endif
  45. #ifndef EXEC_MEMORY_H
  46. #include <exec/memory.h>
  47. #endif
  48. #ifndef DOS_DOSEXTENS_H
  49. #include <dos/dosextens.h>
  50. #endif
  51. #ifndef LIBRARIES_COMMODITIES_H
  52. #include <libraries/commodities.h>
  53. #endif
  54.  
  55. #include <stdio.h>
  56. #include <stdlib.h>
  57. #include <string.h>
  58.  
  59. #include <clib/exec_protos.h>
  60. #include <clib/intuition_protos.h>
  61. #include <clib/gadtools_protos.h>
  62. #include <clib/asl_protos.h>
  63. #include <clib/alib_protos.h>
  64. #include <clib/dos_protos.h>
  65. #include <clib/commodities_protos.h>
  66.  
  67. #include "setwindow.h"
  68.  
  69. const char    idString[] = "$""VER: MSH-Set $Revision: 1.56 $ $Date: 1996/12/22 21:12:51 $\r\n";
  70.  
  71. struct Library *AslBase;
  72. struct Library *GadToolsBase;
  73. struct IntuituinBase *IntuitionBase;
  74. struct Library *CxBase;
  75. struct Library *IconBase;
  76.  
  77. struct PrivateInfo *Private;
  78. char           *HandlerName;
  79. struct MsgPort *HandlerPort;
  80.  
  81. struct MinList    MSHList;
  82. struct MSHNode {
  83.     struct Node     m_Node;
  84.     char        m_Name[2];    /* 1 for ':', 1 for '\0' */
  85. };
  86.  
  87. struct FileRequester *FileRequest;
  88.  
  89. const char    OkString[] = "Ok";
  90. const char    PanicString[] = "Panic!";
  91.  
  92. void        Show(void);
  93. void        Hide(void);
  94. void        SetGadgetAttr(int id, ULONG tag, ULONG value);
  95. void        UpdateGadgets(struct PrivateInfo *p);
  96. void        DeselectHandler(void);
  97.  
  98. /* Commodities stuff: */
  99. UBYTE          **TTypes;
  100. struct NewBroker NewBroker = {
  101.     NB_VERSION,
  102.     "MSH-Set",
  103.     "MSH Settings",
  104.     "Change settings of MSH devices",
  105.     NBU_UNIQUE | NBU_NOTIFY,
  106.     COF_SHOW_HIDE,
  107.     0, 0, 0
  108. };
  109. struct MsgPort *BrokerPort;
  110. CxObj           *Broker;
  111.  
  112. #define EVT_HOTKEY  1
  113.  
  114. /*
  115.  * Arg2 -> Arg2, the world turned upside down.
  116.  */
  117.  
  118. long
  119. dos_packet1a(struct MsgPort *port, long type, long arg2, long arg3)
  120. {
  121.     struct StandardPacket *sp;
  122.     struct MsgPort *rp;
  123.  
  124.     if ((rp = CreatePort(NULL, 0)) == NULL)
  125.     return DOSFALSE;
  126.     if ((sp = AllocMem((long) sizeof (*sp), MEMF_PUBLIC | MEMF_CLEAR)) == NULL) {
  127.     DeletePort(rp);
  128.     return DOSFALSE;
  129.     }
  130.     sp->sp_Msg.mn_Node.ln_Name = (char *) &sp->sp_Pkt;
  131.     sp->sp_Pkt.dp_Link = &sp->sp_Msg;
  132.     sp->sp_Pkt.dp_Port = rp;
  133.     sp->sp_Pkt.dp_Type = type;
  134.     sp->sp_Pkt.dp_Arg2 = arg2;
  135.     sp->sp_Pkt.dp_Arg3 = arg3;
  136.     PutMsg(port, &sp->sp_Msg);
  137.     WaitPort(rp);
  138.     GetMsg(rp);
  139.     arg2 = sp->sp_Pkt.dp_Arg2;
  140.     FreeMem(sp, (long) sizeof (*sp));
  141.     DeletePort(rp);
  142.  
  143.     return arg2;
  144. }
  145.  
  146. struct PrivateInfo *
  147. GetPrivateInfo(struct MsgPort *port, int lockcount)
  148. {
  149.     if (port) {
  150.     struct PrivateInfo *p;
  151.  
  152.     p = (struct PrivateInfo *)
  153.         dos_packet1a(port, ACTION_CURRENT_VOLUME, MSH_MAGIC, lockcount);
  154.  
  155.     if ((long) p == MSH_MAGIC ||
  156.         p == NULL ||
  157.         p->Revision != PRIVATE_REVISION ||
  158.         p->Size != sizeof(*p)) {
  159.         /* Incompatible filesystem. */
  160.  
  161.         return NULL;
  162.     }
  163.  
  164.     return p;
  165.     }
  166.     return NULL;
  167. }
  168.  
  169. /* Commodities stuff: */
  170.  
  171. void
  172. KillCx(void)
  173. {
  174.     if (CxBase) {
  175.     if (Broker) {
  176.         DeleteCxObjAll(Broker);
  177.         Broker = NULL;
  178.     }
  179.     if (BrokerPort) {
  180.         struct Message *msg;
  181.  
  182.         while (msg = GetMsg(BrokerPort)) {
  183.         ReplyMsg(msg);
  184.         }
  185.         DeleteMsgPort(BrokerPort);
  186.         BrokerPort = NULL;
  187.     }
  188.     CloseLibrary(CxBase);
  189.     CxBase = NULL;
  190.     }
  191.     if (IconBase) {
  192.     CloseLibrary(IconBase);
  193.     IconBase = NULL;
  194.     }
  195. }
  196.  
  197. void
  198. Die(void)
  199. {
  200.     Hide();
  201.  
  202.     if (FileRequest)
  203.     FreeAslRequest(FileRequest);
  204.  
  205.     KillCx();
  206.     if (IntuitionBase) {
  207.     CloseLibrary(IntuitionBase);
  208.     IntuitionBase = NULL;
  209.     }
  210.     if (GadToolsBase) {
  211.     CloseLibrary(GadToolsBase);
  212.     GadToolsBase = NULL;
  213.     }
  214.     if (AslBase) {
  215.     CloseLibrary(AslBase);
  216.     AslBase = NULL;
  217.     }
  218.     exit(0);
  219. }
  220.  
  221. void
  222. OpenAll(int argc, char **argv)
  223. {
  224.     extern struct Library *DOSBase;
  225.     int         doshow = 1;
  226.  
  227.     NewList((struct List *) &MSHList);
  228.  
  229.     if (DOSBase->lib_Version < 37) {
  230.     puts("Sorry, requires at least V37...");
  231.     Die();
  232.     }
  233.     AslBase = OpenLibrary("asl.library", 37L);
  234.     if (!AslBase)
  235.     Die();
  236.  
  237.     GadToolsBase = OpenLibrary("gadtools.library", 37L);
  238.     if (!GadToolsBase)
  239.     Die();
  240.  
  241.     IntuitionBase = OpenLibrary("intuition.library", 37L);
  242.     if (!IntuitionBase)
  243.     Die();
  244.  
  245.     /*
  246.      * The following is Commodities stuff.
  247.      * We still run if it fails to open, but not if we can't register.
  248.      */
  249.  
  250.     CxBase = OpenLibrary("commodities.library", 37L);
  251.  
  252.     if (CxBase) {
  253.     CxObj           *filter;
  254.     long        error = CBERR_OK;
  255.     char        popup;
  256.  
  257.     IconBase = OpenLibrary("icon.library", 37L);
  258.     if (!IconBase)
  259.         goto no_cx;
  260.  
  261.     TTypes = ArgArrayInit(argc, argv);
  262.  
  263.     BrokerPort = CreateMsgPort();
  264.     NewBroker.nb_Port = BrokerPort;
  265.     NewBroker.nb_Pri = ArgInt(TTypes, "CX_PRIORITY", 0);
  266.  
  267.     Broker = CxBroker(&NewBroker, &error);
  268.  
  269.     filter = HotKey(ArgString(TTypes, "CX_POPKEY", "rawkey control alt m"),
  270.             BrokerPort, EVT_HOTKEY);
  271.  
  272.     popup = *ArgString(TTypes, "CX_POPUP", "Y");
  273.  
  274.     ArgArrayDone();
  275.  
  276.     /*
  277.      * If something goes wrong with commodities, we still run,
  278.      * except when we violate the commodity uniqueness.
  279.      */
  280.  
  281.     if (!BrokerPort || !Broker || !filter) {
  282.         if (filter)
  283.         DeleteCxObjAll(filter);
  284.         if (error == CBERR_DUP)
  285.         Die();
  286.         KillCx();
  287.         goto no_cx;
  288.     }
  289.  
  290.     AttachCxObj(Broker, filter);
  291.     if (!CxObjError(filter)) {
  292.         ActivateCxObj(Broker, 1L);
  293.         if (popup == 'N') {
  294.         doshow = 0;
  295.         }
  296.     }
  297.     }
  298. no_cx:
  299.     if (doshow)
  300.     Show();
  301. }
  302.  
  303. void
  304. FindAllMSHs(void)
  305. {
  306.     struct DosList *dlist;
  307.  
  308.     dlist = LockDosList(LDF_DEVICES | LDF_READ);
  309.  
  310.     while (dlist = NextDosEntry(dlist, LDF_DEVICES)) {
  311.     struct PrivateInfo *p;
  312.  
  313.     if (p = GetPrivateInfo(dlist->dol_Task, 0)) {
  314.         char       *name;
  315.         struct MSHNode *node;
  316.  
  317.         name = (char *) BADDR(dlist->dol_Name);
  318.         node = AllocVec(sizeof (*node) + name[0], MEMF_CLEAR);
  319.         if (node) {
  320.         strncpy(node->m_Name, &name[1], name[0]);
  321.         strcpy(node->m_Name + name[0], ":");
  322.  
  323.         node->m_Node.ln_Name = node->m_Name;
  324.         AddHead((struct List *) & MSHList, &node->m_Node);
  325.         }
  326.     }
  327.     }
  328.  
  329.     UnLockDosList(LDF_DEVICES | LDF_READ);
  330. }
  331.  
  332. void
  333. ForgetAllMSHs(void)
  334. {
  335.     struct Node    *n,
  336.            *nn;
  337.  
  338.     n = (struct Node *)MSHList.mlh_Head;
  339.     while (nn = n->ln_Succ) {
  340.     FreeVec(n);
  341.     n = nn;
  342.     }
  343.     NewList((struct List *) &MSHList);
  344. }
  345.  
  346. void
  347. Show(void)
  348. {
  349.     if (MSHSettingsWnd) {
  350.     WindowToFront(MSHSettingsWnd);
  351.     return;         /* already open */
  352.     }
  353.  
  354.     if (SetupScreen())
  355.     Die();
  356.  
  357.     if (OpenMSHSettingsWindow())
  358.     Die();
  359.  
  360.     if (BrokerPort) {
  361.     OnMenu(MSHSettingsWnd, FULLMENUNUM(0, 0, NOSUB));   /* "Hide A-H" */
  362.     }
  363.  
  364.     FindAllMSHs();
  365.     SetGadgetAttr(GDX_HANDLERS, GTLV_Labels, (ULONG) &MSHList);
  366.     UpdateGadgets(Private);
  367. }
  368.  
  369. void
  370. Hide(void)
  371. {
  372.     if (MSHSettingsWnd) {
  373.     struct Message *msg;
  374.  
  375.     MSHSettingsLeft = MSHSettingsWnd->LeftEdge;
  376.     MSHSettingsTop = MSHSettingsWnd->TopEdge;
  377.  
  378.     while (msg = GetMsg(MSHSettingsWnd->UserPort)) {
  379.         ReplyMsg(msg);
  380.     }
  381.     }
  382.  
  383.     DeselectHandler();
  384.     CloseMSHSettingsWindow();
  385.     CloseDownScreen();
  386.     ForgetAllMSHs();
  387. }
  388.  
  389. struct Node    *
  390. GetNode(struct MinList *l, int num)
  391. {
  392.     struct Node    *n,
  393.            *nn;
  394.  
  395.     n = (struct Node *)l->mlh_Head;
  396.     while (num > 0 && (nn = n->ln_Succ)) {
  397.     num--;
  398.     n = nn;
  399.     }
  400.  
  401.     return n;
  402. }
  403.  
  404. void
  405. SetGadgetAttr(int id, ULONG tag, ULONG value)
  406. {
  407.     GT_SetGadgetAttrs(MSHSettingsGadgets[id], MSHSettingsWnd, NULL,
  408.               tag, value,
  409.               TAG_END);
  410. }
  411.  
  412. void
  413. UpdateLoadGadget(int i)
  414. {
  415.     SetGadgetAttr(GDX_LOAD, GA_Disabled, i == 0);
  416. }
  417.  
  418. void
  419. DisableGadgets(long i)
  420. {
  421.     SetGadgetAttr(GDX_MD40TRACK, GA_Disabled, i);
  422.     SetGadgetAttr(GDX_BOOTJMP, GA_Disabled, i);
  423.     SetGadgetAttr(GDX_SANITY, GA_Disabled, i);
  424.     SetGadgetAttr(GDX_SAN_DEFAULT, GA_Disabled, i);
  425.     SetGadgetAttr(GDX_USE_DEFAULT, GA_Disabled, i);
  426.     SetGadgetAttr(GDX_CONVERSION, GA_Disabled, i);
  427.     SetGadgetAttr(GDX_LOAD, GA_Disabled, i);
  428. }
  429.  
  430. void
  431. UpdateGadgetsDis(unsigned short i)
  432. {
  433.     SetGadgetAttr(GDX_SANITY, GA_Disabled, (i & CHECK_USE_DEFAULT) != 0);
  434.     SetGadgetAttr(GDX_SAN_DEFAULT, GA_Disabled,
  435.         (i & (CHECK_SANITY|CHECK_USE_DEFAULT)) != CHECK_SANITY);
  436. }
  437.  
  438. void
  439. UpdateGadgets(struct PrivateInfo *p)
  440. {
  441.     if (p) {
  442.     long        i;
  443.  
  444.     DisableGadgets(FALSE);
  445.  
  446.     i = (*p->DiskIOReq)->iotd_Req.io_Flags;
  447.  
  448.     SetGadgetAttr(GDX_MD40TRACK, GTCB_Checked, (i & IOMDF_40TRACKS) != 0);
  449.  
  450.     i = *p->CheckBootBlock;
  451.  
  452.     UpdateGadgetsDis(i);
  453.     SetGadgetAttr(GDX_BOOTJMP, GTCB_Checked, (i & CHECK_BOOTJMP) != 0);
  454.     SetGadgetAttr(GDX_SANITY, GTCB_Checked, (i & CHECK_SANITY) != 0);
  455.     SetGadgetAttr(GDX_SAN_DEFAULT, GTCB_Checked, (i & CHECK_SAN_DEFAULT) != 0);
  456.     SetGadgetAttr(GDX_USE_DEFAULT, GTCB_Checked, (i & CHECK_USE_DEFAULT) != 0);
  457.  
  458.     i = *p->DefaultConversion - ConvNone;
  459.  
  460.     SetGadgetAttr(GDX_CONVERSION, GTCY_Active, i);
  461.     UpdateLoadGadget(i);
  462.     } else {
  463.     DisableGadgets(TRUE);
  464.     }
  465. }
  466.  
  467. void
  468. DeselectHandler(void)
  469. {
  470.     if (HandlerPort) {
  471.     GetPrivateInfo(HandlerPort, -1);
  472.     HandlerPort = NULL;
  473.     }
  474.     Private = NULL;
  475.     HandlerName = NULL;
  476. }
  477.  
  478. struct PrivateInfo *
  479. SelectHandler(char *name)
  480. {
  481.     struct MsgPort *filehandler;
  482.     struct PrivateInfo *p;
  483.  
  484.     DeselectHandler();
  485.  
  486.     filehandler = DeviceProc(name);
  487.  
  488.     if (filehandler == 0) {
  489.     struct EasyStruct er = {
  490.         sizeof er, 0, PanicString,
  491.         "Cannot find\n%s",
  492.         OkString
  493.     };
  494.  
  495.     EasyRequest(MSHSettingsWnd, &er, NULL, name);
  496.     }
  497.  
  498.     p = GetPrivateInfo(filehandler, 1);
  499.     UpdateGadgets(p);
  500.     if (p) {
  501.     HandlerName = name;
  502.     HandlerPort = filehandler;
  503.     }
  504.  
  505.     Private = p;
  506.     return p;
  507. }
  508.  
  509. unsigned char  *
  510. InstallTable(unsigned char **ptr, unsigned char *init)
  511. {
  512.     Forbid();
  513.  
  514.     if (init) {
  515.     if (*ptr == NULL)
  516.         *ptr = AllocMem(256L, 0L);
  517.     if (*ptr != NULL)
  518.         CopyMem(init, *ptr, 256L);
  519.     } else if (*ptr != NULL) {
  520.     FreeMem(*ptr, 256L);
  521.     *ptr = NULL;
  522.     }
  523.     Permit();
  524.  
  525.     return *ptr;
  526. }
  527.  
  528. void
  529. DoLoad(long qualifier)
  530. {
  531.     struct FileRequester *fr;
  532.     struct PrivateInfo *p;
  533.     int         conversion;
  534.  
  535.     p = Private;
  536.     if (!p) {
  537.     return;
  538.     }
  539.     conversion = *p->DefaultConversion;
  540.     if (conversion >= ConvFence)
  541.     conversion = ConvNone;
  542.  
  543.     if (conversion == ConvNone ||
  544.     conversion > p->NumConversions) {
  545.     struct EasyStruct er = {
  546.         sizeof er, 0, PanicString,
  547.         "Incorrect conversion %lc\nfor %s:",
  548.         OkString
  549.     };
  550.  
  551.     EasyRequest(MSHSettingsWnd, &er, NULL,
  552.             (APTR)('@'+conversion), HandlerName);
  553.  
  554.     return;
  555.     }
  556.     conversion -= ConvNone + 1; /* Make it 0-based */
  557.  
  558.     /* If hit with shift, unload existing table */
  559.     if (qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)) {
  560.     struct EasyStruct er = {
  561.         sizeof er, 0, NULL,
  562.         "Reset %lc-conversion table?",
  563.         "Ok|Cancel"
  564.     };
  565.     long        reply;
  566.  
  567.     reply = EasyRequest(MSHSettingsWnd, &er, NULL,
  568.             (APTR)('@' + ConvNone + 1 + conversion));
  569.  
  570.     if (reply) {
  571.         InstallTable(p->Table[conversion].to, NULL);
  572.         InstallTable(p->Table[conversion].from, NULL);
  573.     }
  574.  
  575.     return;
  576.     }
  577.     if (FileRequest == NULL) {
  578.     FileRequest = (struct FileRequester *)
  579.     AllocAslRequestTags(ASL_FileRequest,
  580.                 ASL_Hail, "Select a conversion table",
  581.                 TAG_DONE);
  582.     }
  583.  
  584.     if (fr = FileRequest) {
  585.     unsigned char    table[256];
  586.     BPTR        file;
  587.  
  588.     if (AslRequest(fr, NULL) == 0) {
  589.         goto end;
  590.     }
  591.     strncpy(table, fr->rf_Dir, sizeof (table) - 1);
  592.     AddPart(table, fr->rf_File, sizeof (table) - 1);
  593.  
  594.     file = Open(table, MODE_OLDFILE);
  595.     if (file == 0) {
  596.         struct EasyStruct er = {
  597.         sizeof er, 0, NULL,
  598.         "Cannot open table\n%s",
  599.         OkString
  600.         };
  601.  
  602.         EasyRequest(MSHSettingsWnd, &er, NULL, table);
  603.         goto end;
  604.     }
  605.     if (Read(file, table, sizeof (table)) == 256)
  606.         InstallTable(p->Table[conversion].to, table);
  607.  
  608.     if (Read(file, table, sizeof (table)) == 256)
  609.         InstallTable(p->Table[conversion].from, table);
  610.  
  611.     Close(file);
  612.     end:
  613.     }
  614. }
  615.  
  616. int
  617. DoGadget(struct IntuiMessage *imsg)
  618. {
  619.     struct Gadget  *gd;
  620.     int         id;
  621.     struct PrivateInfo *p;
  622.  
  623.     gd = (struct Gadget *) imsg->IAddress;
  624.     id = gd->GadgetID;
  625.  
  626.     switch (id) {
  627.     case GD_HANDLERS:
  628.     {
  629.         struct Node    *n;
  630.  
  631.         n = GetNode(&MSHList, imsg->Code);
  632.         SelectHandler(n->ln_Name);
  633.     }
  634.     return 0;
  635.     case GD_LOAD:
  636.     DoLoad(imsg->Qualifier);
  637.     return 0;
  638.     }
  639.  
  640.     p = Private;
  641.     if (!p)
  642.     return 0;
  643.  
  644.     /* Following all assume Private is valid */
  645.  
  646.     switch (id) {
  647.     case GD_MD40TRACK:
  648.     {
  649.         struct IOExtTD *io;
  650.  
  651.         if (io = *p->DiskIOReq) {
  652.         if (gd->Flags & GFLG_SELECTED) {
  653.             io->iotd_Req.io_Flags |= IOMDF_40TRACKS;
  654.         } else {
  655.             io->iotd_Req.io_Flags &= ~IOMDF_40TRACKS;
  656.         }
  657.         }
  658.     }
  659.     break;
  660.     case GD_BOOTJMP:
  661.     {
  662.         short *f = p->CheckBootBlock;
  663.  
  664.         if (gd->Flags & GFLG_SELECTED) {
  665.         *f |= CHECK_BOOTJMP;
  666.         } else {
  667.         *f &= ~CHECK_BOOTJMP;
  668.         }
  669.     }
  670.     break;
  671.     case GD_SANITY:
  672.     {
  673.         short *f = p->CheckBootBlock;
  674.  
  675.         if (gd->Flags & GFLG_SELECTED) {
  676.         *f |= CHECK_SANITY;
  677.         } else {
  678.         *f &= ~CHECK_SANITY;
  679.         }
  680.         UpdateGadgetsDis(*f);
  681.     }
  682.     break;
  683.     case GD_SAN_DEFAULT:
  684.     {
  685.         short *f = p->CheckBootBlock;
  686.  
  687.         if (gd->Flags & GFLG_SELECTED) {
  688.         *f |= CHECK_SAN_DEFAULT;
  689.         } else {
  690.         *f &= ~CHECK_SAN_DEFAULT;
  691.         }
  692.     }
  693.     break;
  694.     case GD_USE_DEFAULT:
  695.     {
  696.         short *f = p->CheckBootBlock;
  697.  
  698.         if (gd->Flags & GFLG_SELECTED) {
  699.         *f |= CHECK_USE_DEFAULT;
  700.         } else {
  701.         *f &= ~CHECK_USE_DEFAULT;
  702.         }
  703.         UpdateGadgetsDis(*f);
  704.     }
  705.     break;
  706.     case GD_CONVERSION:
  707.     *p->DefaultConversion = imsg->Code + ConvNone;
  708.     UpdateLoadGadget(imsg->Code);
  709.     break;
  710.     }
  711.  
  712.     return 0;
  713. }
  714.  
  715. void
  716. MainLoop(void)
  717. {
  718.     long        waitmask;
  719.     long        windowmask;
  720.     long        brokermask;
  721.     long        mask;
  722.     int         done;
  723.  
  724. top:
  725.     done = 0;
  726.  
  727.     if (MSHSettingsWnd)
  728.     windowmask = 1L << MSHSettingsWnd->UserPort->mp_SigBit;
  729.     else
  730.     windowmask = 0;
  731.     if (BrokerPort)
  732.     brokermask = 1L << BrokerPort->mp_SigBit;
  733.      else
  734.     brokermask = 0;
  735.  
  736.     waitmask = windowmask | brokermask | SIGBREAKF_CTRL_C;
  737.  
  738.     while (!done) {
  739.     mask = Wait(waitmask);
  740.     if (mask & SIGBREAKF_CTRL_C) {
  741.         done = 1;
  742.         break;
  743.     }
  744.     /*
  745.      * Note that this part won't be reachable if
  746.      * commodities failed to open.
  747.      */
  748.     if (mask & brokermask) {
  749.         CxMsg       *cxmsg;
  750.  
  751.         while (cxmsg = (CxMsg *)GetMsg(BrokerPort)) {
  752.         int        id;
  753.         int        type;
  754.  
  755.         id = CxMsgID(cxmsg);
  756.         type = CxMsgType(cxmsg);
  757.         ReplyMsg((struct Message *)cxmsg);
  758.  
  759.         switch (type) {
  760.         case CXM_IEVENT:
  761.             if (id == EVT_HOTKEY) {
  762.             goto show;
  763.             }
  764.             break;
  765.         case CXM_COMMAND:
  766.             switch (id) {
  767.             case CXCMD_DISABLE:
  768.             ActivateCxObj(Broker, 0L);
  769.             break;
  770.             case CXCMD_ENABLE:
  771.             ActivateCxObj(Broker, 1L);
  772.             break;
  773.             case CXCMD_APPEAR:
  774.             case CXCMD_UNIQUE:
  775.             show:
  776.             Show();
  777.             goto top;
  778.             case CXCMD_DISAPPEAR:
  779.             hide:
  780.             Hide();
  781.             goto top;
  782.             case CXCMD_KILL:
  783.             done = 1;
  784.             break;
  785.             }
  786.             break;
  787.         }
  788.         }
  789.     }
  790.     if (mask & windowmask) {
  791.         struct IntuiMessage *imsg;
  792.         struct IntuiMessage msg;
  793.  
  794.         while (imsg = GT_GetIMsg(MSHSettingsWnd->UserPort)) {
  795.         msg = *imsg;
  796.         GT_ReplyIMsg(imsg);
  797.  
  798.         switch (msg.Class) {
  799.         case IDCMP_CLOSEWINDOW:
  800.             /*
  801.              * Commodities only hide when you try to close them.
  802.              */
  803.             if (BrokerPort) {
  804.             goto hide;
  805.             } else {
  806.             done = 1;
  807.             }
  808.             break;
  809.         case IDCMP_GADGETUP:
  810.             done = DoGadget(&msg);
  811.             break;
  812.         case IDCMP_MENUPICK:
  813.             switch (ITEMNUM(msg.Code)) {
  814.             case 0:    /* Hide */
  815.             goto hide;
  816.             break;
  817.             case 1:    /* Quit */
  818.             done = 1;
  819.             break;
  820.             }
  821.             break;
  822.         case IDCMP_REFRESHWINDOW:
  823.             GT_BeginRefresh(MSHSettingsWnd);
  824.             GT_EndRefresh(MSHSettingsWnd, TRUE);
  825.             break;
  826.         case IDCMP_DISKINSERTED:
  827.             SelectHandler(HandlerName);
  828.             UpdateGadgets(Private);
  829.             break;
  830.         }
  831.         }
  832.     }
  833.     }
  834. }
  835.  
  836. int
  837. main(int argc, char **argv)
  838. {
  839.     OpenAll(argc, argv);
  840.  
  841.     MainLoop();
  842.     Die();
  843.  
  844.     return 0;
  845. }
  846.  
  847. #ifndef WORKBENCH_STARTUP_H
  848. #include <workbench/startup.h>
  849. #endif
  850.  
  851. int
  852. wbmain(struct WBStartup *wbs)
  853. {
  854.     int         rc;
  855.     long        lock;
  856.  
  857.     if (wbs->sm_ArgList)
  858.     lock = CurrentDir(wbs->sm_ArgList->wa_Lock);
  859.     rc = main(0, (char **)wbs);
  860.     if (wbs->sm_ArgList)
  861.     CurrentDir(lock);
  862.     return rc;
  863. }
  864.